{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import warnings\n",
    "\n",
    "if not sys.warnoptions:\n",
    "    warnings.simplefilter('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from datetime import datetime\n",
    "from datetime import timedelta\n",
    "from tqdm import tqdm\n",
    "sns.set()\n",
    "tf.compat.v1.random.set_random_seed(1234)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Date</th>\n",
       "      <th>Open</th>\n",
       "      <th>High</th>\n",
       "      <th>Low</th>\n",
       "      <th>Close</th>\n",
       "      <th>Adj Close</th>\n",
       "      <th>Volume</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2016-11-02</td>\n",
       "      <td>778.200012</td>\n",
       "      <td>781.650024</td>\n",
       "      <td>763.450012</td>\n",
       "      <td>768.700012</td>\n",
       "      <td>768.700012</td>\n",
       "      <td>1872400</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2016-11-03</td>\n",
       "      <td>767.250000</td>\n",
       "      <td>769.950012</td>\n",
       "      <td>759.030029</td>\n",
       "      <td>762.130005</td>\n",
       "      <td>762.130005</td>\n",
       "      <td>1943200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2016-11-04</td>\n",
       "      <td>750.659973</td>\n",
       "      <td>770.359985</td>\n",
       "      <td>750.560974</td>\n",
       "      <td>762.020020</td>\n",
       "      <td>762.020020</td>\n",
       "      <td>2134800</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2016-11-07</td>\n",
       "      <td>774.500000</td>\n",
       "      <td>785.190002</td>\n",
       "      <td>772.549988</td>\n",
       "      <td>782.520020</td>\n",
       "      <td>782.520020</td>\n",
       "      <td>1585100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2016-11-08</td>\n",
       "      <td>783.400024</td>\n",
       "      <td>795.632996</td>\n",
       "      <td>780.190002</td>\n",
       "      <td>790.510010</td>\n",
       "      <td>790.510010</td>\n",
       "      <td>1350800</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Date        Open        High         Low       Close   Adj Close  \\\n",
       "0  2016-11-02  778.200012  781.650024  763.450012  768.700012  768.700012   \n",
       "1  2016-11-03  767.250000  769.950012  759.030029  762.130005  762.130005   \n",
       "2  2016-11-04  750.659973  770.359985  750.560974  762.020020  762.020020   \n",
       "3  2016-11-07  774.500000  785.190002  772.549988  782.520020  782.520020   \n",
       "4  2016-11-08  783.400024  795.632996  780.190002  790.510010  790.510010   \n",
       "\n",
       "    Volume  \n",
       "0  1872400  \n",
       "1  1943200  \n",
       "2  2134800  \n",
       "3  1585100  \n",
       "4  1350800  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('../dataset/GOOG-year.csv')\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.112708</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.090008</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.089628</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.160459</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.188066</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          0\n",
       "0  0.112708\n",
       "1  0.090008\n",
       "2  0.089628\n",
       "3  0.160459\n",
       "4  0.188066"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minmax = MinMaxScaler().fit(df.iloc[:, 4:5].astype('float32')) # Close index\n",
    "df_log = minmax.transform(df.iloc[:, 4:5].astype('float32')) # Close index\n",
    "df_log = pd.DataFrame(df_log)\n",
    "df_log.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Split train and test\n",
    "\n",
    "I will cut the dataset to train and test datasets,\n",
    "\n",
    "1. Train dataset derived from starting timestamp until last 30 days\n",
    "2. Test dataset derived from last 30 days until end of the dataset\n",
    "\n",
    "So we will let the model do forecasting based on last 30 days, and we will going to repeat the experiment for 10 times. You can increase it locally if you want, and tuning parameters will help you by a lot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((252, 7), (222, 1), (30, 1))"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_size = 30\n",
    "simulation_size = 10\n",
    "\n",
    "df_train = df_log.iloc[:-test_size]\n",
    "df_test = df_log.iloc[-test_size:]\n",
    "df.shape, df_train.shape, df_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model:\n",
    "    def __init__(\n",
    "        self,\n",
    "        learning_rate,\n",
    "        num_layers,\n",
    "        size,\n",
    "        size_layer,\n",
    "        output_size,\n",
    "        forget_bias = 0.1,\n",
    "        lambda_coeff = 0.5\n",
    "    ):\n",
    "        def lstm_cell(size_layer):\n",
    "            return tf.nn.rnn_cell.GRUCell(size_layer)\n",
    "\n",
    "        rnn_cells = tf.nn.rnn_cell.MultiRNNCell(\n",
    "            [lstm_cell(size_layer) for _ in range(num_layers)],\n",
    "            state_is_tuple = False,\n",
    "        )\n",
    "        self.X = tf.placeholder(tf.float32, (None, None, size))\n",
    "        self.Y = tf.placeholder(tf.float32, (None, output_size))\n",
    "        drop = tf.contrib.rnn.DropoutWrapper(\n",
    "            rnn_cells, output_keep_prob = forget_bias\n",
    "        )\n",
    "        self.hidden_layer = tf.placeholder(\n",
    "            tf.float32, (None, num_layers * size_layer)\n",
    "        )\n",
    "        _, last_state = tf.nn.dynamic_rnn(\n",
    "            drop, self.X, initial_state = self.hidden_layer, dtype = tf.float32\n",
    "        )\n",
    "        \n",
    "        self.z_mean = tf.layers.dense(last_state, size)\n",
    "        self.z_log_sigma = tf.layers.dense(last_state, size)\n",
    "        \n",
    "        epsilon = tf.random_normal(tf.shape(self.z_log_sigma))\n",
    "        self.z_vector = self.z_mean + tf.exp(self.z_log_sigma)\n",
    "        \n",
    "        with tf.variable_scope('decoder', reuse = False):\n",
    "            rnn_cells_dec = tf.nn.rnn_cell.MultiRNNCell(\n",
    "                [lstm_cell(size_layer) for _ in range(num_layers)], state_is_tuple = False\n",
    "            )\n",
    "            drop_dec = tf.contrib.rnn.DropoutWrapper(\n",
    "                rnn_cells_dec, output_keep_prob = forget_bias\n",
    "            )\n",
    "            x = tf.concat([tf.expand_dims(self.z_vector, axis=0), self.X], axis = 1)\n",
    "            self.outputs, self.last_state = tf.nn.dynamic_rnn(\n",
    "                drop_dec, self.X, initial_state = last_state, dtype = tf.float32\n",
    "            )\n",
    "            \n",
    "        self.logits = tf.layers.dense(self.outputs[-1], output_size)\n",
    "        self.lambda_coeff = lambda_coeff\n",
    "        \n",
    "        self.kl_loss = -0.5 * tf.reduce_sum(1.0 + 2 * self.z_log_sigma - self.z_mean ** 2 - \n",
    "                             tf.exp(2 * self.z_log_sigma), 1)\n",
    "        self.kl_loss = tf.scalar_mul(self.lambda_coeff, self.kl_loss)\n",
    "        self.cost = tf.reduce_mean(tf.square(self.Y - self.logits) + self.kl_loss)\n",
    "        self.optimizer = tf.train.AdamOptimizer(learning_rate).minimize(\n",
    "            self.cost\n",
    "        )\n",
    "        \n",
    "def calculate_accuracy(real, predict):\n",
    "    real = np.array(real) + 1\n",
    "    predict = np.array(predict) + 1\n",
    "    percentage = 1 - np.sqrt(np.mean(np.square((real - predict) / real)))\n",
    "    return percentage * 100\n",
    "\n",
    "def anchor(signal, weight):\n",
    "    buffer = []\n",
    "    last = signal[0]\n",
    "    for i in signal:\n",
    "        smoothed_val = last * weight + (1 - weight) * i\n",
    "        buffer.append(smoothed_val)\n",
    "        last = smoothed_val\n",
    "    return buffer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_layers = 1\n",
    "size_layer = 128\n",
    "timestamp = 5\n",
    "epoch = 300\n",
    "dropout_rate = 0.8\n",
    "future_day = test_size\n",
    "learning_rate = 0.01"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forecast():\n",
    "    tf.reset_default_graph()\n",
    "    modelnn = Model(\n",
    "        learning_rate, num_layers, df_log.shape[1], size_layer, df_log.shape[1], dropout_rate\n",
    "    )\n",
    "    sess = tf.InteractiveSession()\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    date_ori = pd.to_datetime(df.iloc[:, 0]).tolist()\n",
    "\n",
    "    pbar = tqdm(range(epoch), desc = 'train loop')\n",
    "    for i in pbar:\n",
    "        init_value = np.zeros((1, num_layers * size_layer))\n",
    "        total_loss, total_acc = [], []\n",
    "        for k in range(0, df_train.shape[0] - 1, timestamp):\n",
    "            index = min(k + timestamp, df_train.shape[0] - 1)\n",
    "            batch_x = np.expand_dims(\n",
    "                df_train.iloc[k : index, :].values, axis = 0\n",
    "            )\n",
    "            batch_x = np.random.binomial(1, 0.5, batch_x.shape) * batch_x\n",
    "            batch_y = df_train.iloc[k + 1 : index + 1, :].values\n",
    "            logits, last_state, _, loss = sess.run(\n",
    "                [modelnn.logits, modelnn.last_state, modelnn.optimizer, modelnn.cost],\n",
    "                feed_dict = {\n",
    "                    modelnn.X: batch_x,\n",
    "                    modelnn.Y: batch_y,\n",
    "                    modelnn.hidden_layer: init_value,\n",
    "                },\n",
    "            )        \n",
    "            init_value = last_state\n",
    "            total_loss.append(loss)\n",
    "            total_acc.append(calculate_accuracy(batch_y[:, 0], logits[:, 0]))\n",
    "        pbar.set_postfix(cost = np.mean(total_loss), acc = np.mean(total_acc))\n",
    "    \n",
    "    future_day = test_size\n",
    "\n",
    "    output_predict = np.zeros((df_train.shape[0] + future_day, df_train.shape[1]))\n",
    "    output_predict[0] = df_train.iloc[0]\n",
    "    upper_b = (df_train.shape[0] // timestamp) * timestamp\n",
    "    init_value = np.zeros((1, num_layers * size_layer))\n",
    "\n",
    "    for k in range(0, (df_train.shape[0] // timestamp) * timestamp, timestamp):\n",
    "        out_logits, last_state = sess.run(\n",
    "            [modelnn.logits, modelnn.last_state],\n",
    "            feed_dict = {\n",
    "                modelnn.X: np.expand_dims(\n",
    "                    df_train.iloc[k : k + timestamp], axis = 0\n",
    "                ),\n",
    "                modelnn.hidden_layer: init_value,\n",
    "            },\n",
    "        )\n",
    "        init_value = last_state\n",
    "        output_predict[k + 1 : k + timestamp + 1] = out_logits\n",
    "\n",
    "    if upper_b != df_train.shape[0]:\n",
    "        out_logits, last_state = sess.run(\n",
    "            [modelnn.logits, modelnn.last_state],\n",
    "            feed_dict = {\n",
    "                modelnn.X: np.expand_dims(df_train.iloc[upper_b:], axis = 0),\n",
    "                modelnn.hidden_layer: init_value,\n",
    "            },\n",
    "        )\n",
    "        output_predict[upper_b + 1 : df_train.shape[0] + 1] = out_logits\n",
    "        future_day -= 1\n",
    "        date_ori.append(date_ori[-1] + timedelta(days = 1))\n",
    "\n",
    "    init_value = last_state\n",
    "    \n",
    "    for i in range(future_day):\n",
    "        o = output_predict[-future_day - timestamp + i:-future_day + i]\n",
    "        out_logits, last_state = sess.run(\n",
    "            [modelnn.logits, modelnn.last_state],\n",
    "            feed_dict = {\n",
    "                modelnn.X: np.expand_dims(o, axis = 0),\n",
    "                modelnn.hidden_layer: init_value,\n",
    "            },\n",
    "        )\n",
    "        init_value = last_state\n",
    "        output_predict[-future_day + i] = out_logits[-1]\n",
    "        date_ori.append(date_ori[-1] + timedelta(days = 1))\n",
    "    \n",
    "    output_predict = minmax.inverse_transform(output_predict)\n",
    "    deep_future = anchor(output_predict[:, 0], 0.3)\n",
    "    \n",
    "    return deep_future[-test_size:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Logging before flag parsing goes to stderr.\n",
      "W0816 23:54:04.861056 140552998012736 deprecation.py:323] From <ipython-input-6-f18f06dc1a5f>:13: GRUCell.__init__ (from tensorflow.python.ops.rnn_cell_impl) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "This class is equivalent as tf.keras.layers.GRUCell, and will be replaced by that in Tensorflow 2.0.\n",
      "W0816 23:54:04.862557 140552998012736 deprecation.py:323] From <ipython-input-6-f18f06dc1a5f>:17: MultiRNNCell.__init__ (from tensorflow.python.ops.rnn_cell_impl) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "This class is equivalent as tf.keras.layers.StackedRNNCells, and will be replaced by that in Tensorflow 2.0.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "W0816 23:54:05.179484 140552998012736 lazy_loader.py:50] \n",
      "The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
      "For more information, please see:\n",
      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
      "  * https://github.com/tensorflow/addons\n",
      "  * https://github.com/tensorflow/io (for I/O related ops)\n",
      "If you depend on functionality not listed there, please file an issue.\n",
      "\n",
      "W0816 23:54:05.182720 140552998012736 deprecation.py:323] From <ipython-input-6-f18f06dc1a5f>:28: dynamic_rnn (from tensorflow.python.ops.rnn) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `keras.layers.RNN(cell)`, which is equivalent to this API\n",
      "W0816 23:54:05.374030 140552998012736 deprecation.py:506] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/init_ops.py:1251: calling VarianceScaling.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "W0816 23:54:05.380675 140552998012736 deprecation.py:506] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/rnn_cell_impl.py:564: calling Constant.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "W0816 23:54:05.389776 140552998012736 deprecation.py:506] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/rnn_cell_impl.py:574: calling Zeros.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "W0816 23:54:05.536239 140552998012736 deprecation.py:323] From <ipython-input-6-f18f06dc1a5f>:31: dense (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.dense instead.\n",
      "W0816 23:54:05.986564 140552998012736 deprecation.py:323] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/math_grad.py:1205: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n",
      "train loop: 100%|██████████| 300/300 [01:48<00:00,  2.73it/s, acc=96, cost=0.00448]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 2\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:49<00:00,  2.74it/s, acc=95.6, cost=0.00512]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 3\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:48<00:00,  2.76it/s, acc=96.2, cost=0.0037] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:48<00:00,  2.75it/s, acc=95.5, cost=0.00715]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:48<00:00,  2.78it/s, acc=96.6, cost=0.0041] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 6\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:48<00:00,  2.75it/s, acc=97.3, cost=0.00204]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 7\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:47<00:00,  2.81it/s, acc=62, cost=7.74]     \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 8\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:48<00:00,  2.80it/s, acc=95, cost=0.00699]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 9\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:48<00:00,  2.76it/s, acc=96.8, cost=0.00279]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "simulation 10\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "train loop: 100%|██████████| 300/300 [01:48<00:00,  2.75it/s, acc=97.1, cost=0.00215]\n"
     ]
    }
   ],
   "source": [
    "results = []\n",
    "for i in range(simulation_size):\n",
    "    print('simulation %d'%(i + 1))\n",
    "    results.append(forecast())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "accuracies = [calculate_accuracy(df['Close'].iloc[-test_size:].values, r) for r in results]\n",
    "\n",
    "plt.figure(figsize = (15, 5))\n",
    "for no, r in enumerate(results):\n",
    "    plt.plot(r, label = 'forecast %d'%(no + 1))\n",
    "plt.plot(df['Close'].iloc[-test_size:].values, label = 'true trend', c = 'black')\n",
    "plt.legend()\n",
    "plt.title('average accuracy: %.4f'%(np.mean(accuracies)))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
